home *** CD-ROM | disk | FTP | other *** search
/ Dr. Windows 3 / dr win3.zip / dr win3 / BUSINESS / XLMATH22.ZIP / SOURCE.ZIP / XLAUTO.C < prev    next >
C/C++ Source or Header  |  1993-09-02  |  9KB  |  384 lines
  1. /* --------------------------< Include files >--------------------- */
  2.  
  3. #define WIN31
  4. #define _MSC_VER 800
  5.  
  6. #include <windows.h>
  7. #include <xlcall.h>
  8. #include <framewrk.h>
  9.  
  10. #ifdef _XLMATH
  11. #include "XLMATH.H"
  12. #endif
  13. #ifdef _XLMARK
  14. #include "XLMARK.H"
  15. #endif
  16. #ifdef _XLQC
  17. #include <.\xlqc\xlqc.h>
  18. #endif
  19.  
  20. #include "xlutil.h"
  21.  
  22.  
  23. /* -----------------< Forward xlAPI functions >--------------------- */
  24.  
  25. int __export FAR PASCAL xlAutoOpen(void);
  26. int __export FAR PASCAL xlAutoClose(void);
  27. LPXLOPER __export FAR PASCAL xlAutoRegister(LPXLOPER pxName);
  28. int __export FAR PASCAL xlAutoAdd(void);
  29. int __export FAR PASCAL xlAutoRemove(void);
  30. LPXLOPER __export FAR PASCAL xlAddInManagerInfo(LPXLOPER xAction);
  31.  
  32. /*----------------------------------------------------------------------*\
  33.  
  34.                         General Notes:
  35.  
  36.     Most of these routines are abstracted from the Excel API
  37.  
  38.     Several of the routines require XLL specific names and these
  39.     are abstracted from the header files specific to each XLL
  40.     
  41. \*----------------------------------------------------------------------*/
  42.  
  43.  
  44.  
  45. /* -----------------------<XLL Routines>--------------------------- */
  46.  
  47. /*
  48. ** xlAutoFree
  49. **
  50. ** xlAutoFree is called by Excel to allow the DLL to free memory.
  51. ** In the DLL, all XLOPER arrays returned to Excel will be freed
  52. ** here. By definition, the address of the XLOPER returned to Excel
  53. ** is the address of the MULTI structure used to allocate the complete
  54. ** array.
  55. */
  56. void __export FAR PASCAL xlAutoFree(LPXLOPER lpMulti)
  57. {
  58.  
  59. #ifdef DEBUG
  60.     // all calls to xlAutoFree are xltypeMulti
  61.     if ((lpMulti->xltype&0xFFF) != xltypeMulti)
  62.         debugPrintf("xlAutoFree() - non-Multi type: %u", lpMulti->xltype);
  63. #endif
  64.  
  65. #ifdef _USE_SMARTHEAP
  66.  
  67.     // always check for a valid pointer
  68.     if (MemCheckPtr(gReturnPool, (LPVOID)lpMulti))
  69.     {
  70.         // and check for good free
  71.         if ( !MemFreePtr((LPVOID)lpMulti))
  72.             OkMsgBox("xlAutoFree() error freeing valid pointer");
  73.     }
  74.     else
  75.     {
  76.         OkMsgBox("xlAutoFree() invalid pointer");
  77.     }
  78.  
  79.     FreeMem((LPVOID)lpMulti);
  80.  
  81. #else    
  82.     // old-fashioned memory allocation
  83.     FreeMem((LPVOID)lpMulti);
  84.     _fheapmin();
  85.     _nheapmin();
  86. #endif
  87. }
  88.  
  89. /*
  90. ** xlAutoOpen
  91. **
  92. ** xlAutoOpen is how Excel loads XLL files.
  93. ** The only thing Excel does when the user
  94. ** opens an XLL file, is call the xlAutoOpen
  95. ** function.
  96. */
  97.  
  98. int __export FAR PASCAL xlAutoOpen(void)
  99. {
  100.     static XLOPER   xDLL,           /* The name of this DLL */
  101.                     xArgs[7],       /* The last 7 arguments to REGISTER */
  102.                     xMenu,            // the xltypeMulti containing the menu
  103.                     xTest,            // test if menu exists
  104.                     FAR *pxMenu,    // points to first menu item
  105.                     FAR *px;        // points to the current menu item
  106.     int             i, j;           /* Loop indices */
  107.     HANDLE            hMenu;            // Windows global memory holding menu
  108.  
  109.  
  110.     /*
  111.     ** Register all the functions. Functions must
  112.     ** be registered before you can add a menu.
  113.     */
  114.  
  115.     Excel(xlGetName, &xDLL, 0);
  116.  
  117.     for (i=0; i<rgFuncsRows; i++)
  118.     {
  119.  
  120.         for (j=0; j<7; j++)
  121.         {
  122.             xArgs[j].xltype = xltypeStr;
  123.             xArgs[j].val.str = rgFuncs[i][j];
  124.         }
  125.  
  126.         Excel(xlfRegister, 0, 8,
  127.             (LPXLOPER) &xDLL,
  128.             (LPXLOPER) &xArgs[0],
  129.             (LPXLOPER) &xArgs[1],
  130.             (LPXLOPER) &xArgs[2],
  131.             (LPXLOPER) &xArgs[3],
  132.             (LPXLOPER) &xArgs[4],
  133.             (LPXLOPER) &xArgs[5],
  134.             (LPXLOPER) &xArgs[6]);
  135.     }
  136.  
  137.  
  138.     // Create "standalone DLL" menu
  139.  
  140.     Excel(xlfGetBar, &xTest, 3, TempInt(1), TempStr((LPSTR)gspShortLibName),
  141.          TempInt(0));
  142.     if (xTest.xltype == xltypeErr)
  143.     {
  144.         // allocate & build menu
  145.         px = pxMenu = (LPXLOPER)GlobalLock(hMenu = GlobalAlloc(GMEM_MOVEABLE,
  146.                             sizeof(XLOPER)*5*rgMenuRows));
  147.         for (i=0; i<rgMenuRows; i++)
  148.         {
  149.             for (j=0; j<5; j++)
  150.             {
  151.                 px->xltype = xltypeStr;
  152.                 px->val.str = rgMenu[i][j];
  153.                 px++;
  154.             }
  155.         }
  156.  
  157.         xMenu.xltype = xltypeMulti;
  158.         xMenu.val.array.lparray = pxMenu;
  159.         xMenu.val.array.rows = rgMenuRows;
  160.         xMenu.val.array.columns = 5;
  161.  
  162.         // does not work unless "Help" found
  163.         Excel (xlfAddMenu, &xTest, 3, TempNum(1), (LPXLOPER)&xMenu, 
  164.                 TempStr(" Help"));
  165.         if (xTest.xltype == xltypeErr)
  166.         {
  167.             // then add at end of menu bar
  168. #ifdef DEBUG
  169.             debugPrintf("Menu added to end");
  170. #endif
  171.             Excel(xlfAddMenu, 0, 2, TempNum(1), (LPXLOPER)&xMenu);
  172.         }
  173.  
  174.         GlobalUnlock(hMenu);
  175.         GlobalFree(hMenu);
  176.     }
  177.  
  178.     Excel(xlFree, 0, 2, (LPXLOPER) &xTest, (LPXLOPER) &xDLL);
  179.  
  180.     return 1;
  181. }
  182.  
  183.  
  184. /*
  185. ** xlAutoClose
  186. **
  187. */
  188.  
  189. int __export FAR PASCAL xlAutoClose(void)
  190. {
  191.     int i;
  192.     XLOPER x;
  193.  
  194.     /*
  195.     ** Delete the names added by xlAutoOpen
  196.     */
  197.  
  198.     for (i=0; i<rgFuncsRows; i++)
  199.     {
  200.         Excel(xlfSetName, 0, 1, TempStr(rgFuncs[i][2]));
  201.     }
  202.  
  203.     // Delete the menu
  204.     Excel(xlfGetBar, &x, 3, TempInt(1), TempStr((LPSTR)gspShortLibName),
  205.                 TempInt(0));
  206.     if (x.xltype  != xltypeErr)
  207.     {
  208.         Excel(xlfDeleteMenu, 0, 2, TempNum(1), TempStr((LPSTR)gspShortLibName));
  209.         Excel(xlFree, 0, 1, (LPXLOPER)&x);
  210.     }
  211.  
  212.     return 1;
  213. }
  214.  
  215. /*
  216. ** xlAutoRegister
  217. **
  218. */
  219.  
  220. LPXLOPER __export FAR PASCAL xlAutoRegister(LPXLOPER pxName)
  221. {
  222.     static XLOPER xDLL, xArgs[7], xRegId;
  223.     int i, j;
  224.  
  225.     xRegId.xltype = xltypeErr;
  226.     xRegId.val.err = xlerrValue;
  227.  
  228.     for (i=0; i<rgFuncsRows; i++)
  229.     {
  230.         if (!lpstricmp(rgFuncs[i][0], pxName->val.str))
  231.         {
  232.             xDLL.xltype = xltypeStr;
  233.             xDLL.val.str = (LPSTR)gspShortLibName;
  234.  
  235.             for (j=0; j<7; j++)
  236.             {
  237.                 xArgs[j].xltype = xltypeStr;
  238.                 xArgs[j].val.str = rgFuncs[i][j];
  239.             }
  240.  
  241.             Excel(xlfRegister, &xRegId, 8,
  242.                 (LPXLOPER) &xDLL,
  243.                 (LPXLOPER) &xArgs[0],
  244.                 (LPXLOPER) &xArgs[1],
  245.                 (LPXLOPER) &xArgs[2],
  246.                 (LPXLOPER) &xArgs[3],
  247.                 (LPXLOPER) &xArgs[4],
  248.                 (LPXLOPER) &xArgs[5],
  249.                 (LPXLOPER) &xArgs[6]);
  250.  
  251.  
  252.             return (LPXLOPER) &xRegId;
  253.         }
  254.     }
  255.  
  256.     return (LPXLOPER) &xRegId;
  257. }
  258.  
  259.  
  260. /*
  261. ** xlAutoAdd
  262. **
  263. ** Called by the Add-In Manager only. When the user
  264. ** adds a DLL to the list of active add-ins, the
  265. ** Add-In Manager calls xlAutoAdd() and then opens
  266. ** the XLL, which in turn calls xlAutoOpen.
  267. **
  268. */
  269.  
  270. int __export FAR PASCAL xlAutoAdd(void)
  271. {
  272.     static char chBuff[80];
  273.     lstrcpy((LPSTR)chBuff, " Thank you for adding ");
  274.     lstrcat((LPSTR)chBuff, (LPSTR)gszLibName);
  275.     Excel(xlcAlert, 0, 2, TempStr((LPSTR)chBuff),
  276.         TempInt(2));
  277.     return 1;
  278. }
  279.  
  280.  
  281. /*
  282. ** xlAutoRemove
  283. **
  284. ** Called by the Add-In Manager only. When the
  285. ** user removes an XLL from the list of active
  286. ** add-ins, the Add-In Manager calls xlAutoRemove()
  287. ** and then UNREGISTER("standalone dll").
  288. */
  289.  
  290. int __export FAR PASCAL xlAutoRemove(void)
  291. {
  292.     static char chBuff[80];
  293.     lstrcpy((LPSTR)chBuff, " Thank you for removing ");
  294.     lstrcat((LPSTR)chBuff, gszLibName);
  295.     Excel(xlcAlert, 0, 2, TempStr((LPSTR)chBuff), TempInt(2));
  296.     return 1;
  297. }
  298.  
  299.  
  300. /* xlAddInManagerInfo
  301. **
  302. **
  303. ** Called by the Add-In Manager to find out some
  304. ** things it needs to know about add-ins.
  305. */
  306.  
  307. LPXLOPER __export FAR PASCAL xlAddInManagerInfo(LPXLOPER xAction)
  308. {
  309.     static XLOPER xInfo, xIntAction;
  310.  
  311.     Excel(xlCoerce, &xIntAction, 2, xAction, TempInt(xltypeInt));
  312.  
  313.     if(xIntAction.val.w == 1)
  314.     {
  315.         xInfo.xltype = xltypeStr;
  316.         xInfo.val.str = (char *)gspLongLibName;
  317.     }
  318.     else
  319.     {
  320.         xInfo.xltype = xltypeErr;
  321.         xInfo.val.err = xlerrValue;
  322.     }
  323.  
  324.     return (LPXLOPER) &xInfo;
  325.  
  326. }
  327. //
  328. //    fExit() - remove standalone DLL functions
  329. //
  330. int FAR PASCAL __export fExit(VOID)
  331. {
  332.     XLOPER  xDLL,                   /* The name of this DLL */
  333.             xFunc,                  /* The name of the function */
  334.             xRegId;                 /* The registration ID */
  335.     int     i;
  336.  
  337.     if ( (MessageBox(NULL, "Do you really want to remove the Add-In tools",
  338.         (LPSTR)gszLibName, MB_APPLMODAL|MB_YESNO|MB_ICONQUESTION)) != IDYES)
  339.         return 0;
  340.  
  341.     xFunc.xltype = xltypeStr